home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / sig / signals.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-19  |  40.9 KB  |  1,408 lines
  1. /* 
  2.  * signals.c --
  3.  *
  4.  * Copyright 1988 Regents of the University of California.
  5.  * Permission to use, copy, modify, and distribute this
  6.  * software and its documentation for any purpose and without
  7.  * fee is hereby granted, provided that the above copyright
  8.  * notice appear in all copies.  The University of California
  9.  * makes no representations about the suitability of this
  10.  * software for any purpose.  It is provided "as is" without
  11.  * express or implied warranty.
  12.  *
  13.  * This contains routines that deal with Sprite signals.  See the man pages
  14.  * on signals for an explanation of the Sprite signaling facilities.  The
  15.  * only thing that is explained in these comments is the implementation of
  16.  * these facilities.
  17.  *
  18.  * SYNCHRONIZATION
  19.  *
  20.  * Whenever the signal state of a process is modified, the sig monitor lock
  21.  * is usually grabbed, and the process is usually locked (e.g., LocalSend).
  22.  * Code that doesn't obtain the sig monitor lock is in migration and
  23.  * signals initialization (e.g., fork & exec); the process is locked in
  24.  * these cases.  Currently (18-Dec-1991) code that doesn't lock the process
  25.  * (e.g., some calls to SigClearPendingMask) only works on the current
  26.  * process (i.e., a process is changing its own pending signals list), and
  27.  * is therefore unlikely to interfere with the code that didn't obtain the
  28.  * sig monitor lock.  (XXX This really ought to get cleaned up.)
  29.  * 
  30.  * When the signal state is looked at no locking is done.  It is assumed
  31.  * that there are two ways that the signal state will be looked at:
  32.  *
  33.  *      1) A process in the middle of executing a system call
  34.  *         will check to see if any signals are pending before waiting for
  35.  *         an extended period (i.e. waiting for a read to complete).  If
  36.  *         not then it will go to sleep until either a signal comes in or
  37.  *         the thing that it is waiting for completes.  This does not
  38.  *         require any synchronization on reading because the routine
  39.  *         which is used to put a process to sleep (see Sync_WaitEventInt)
  40.  *         will check for signals with the master lock down before the
  41.  *         process is put to sleep.  If there are signals pending, then
  42.  *         the sleep call will return immediately.  Otherwise if a signal
  43.  *         comes in after the process goes to sleep then it will be
  44.  *         awakened by the Sig_Send which calls Sync_WakeWaitingProcess which
  45.  *       synchronizes correctly with the Sync_Wait calls.  Thus there
  46.  *       is no way to miss a signal in this case.
  47.  *
  48.  *    2) A process is returning to user mode after trapping into the kernel
  49.  *       for some reason and it wants to see if signals are pending before
  50.  *       it returns.  In this case the trap handler (see Exc_Trap) will 
  51.  *       disable interrupts before checking to see if signals are pending.  
  52.  *       If they are then it will enable interrupts and process the signal.
  53.  *       Otherwise it will return to user mode with interrupts being enabled
  54.  *       on the return to user mode.  If a signal came in when 
  55.  *       interrupts were disabled then once interrupts are enabled the 
  56.  *       process will be interrupted and return back into the kernel.  
  57.  *       Likewise once the user process returns to user mode if a signal is 
  58.  *       delivered then the user process will be interrupted.  Interruption
  59.  *       is possible of course only on a multi-processor. Once interrupted it
  60.  *       will be forced back into the kernel where it will discover a
  61.  *       signal.  Thus a signal cannot be missed in this case either.
  62.  *
  63.  */
  64.  
  65. #ifndef lint
  66. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/sig/signals.c,v 9.15 92/04/10 16:42:00 kupfer Exp $ SPRITE (Berkeley)";
  67. #endif not lint
  68.  
  69. #include <sprite.h>
  70. #include <stdlib.h>
  71. #include <sig.h>
  72. #include <sync.h>
  73. #include <dbg.h>
  74. #include <list.h>
  75. #include <proc.h>
  76. #include <procMigrate.h>
  77. #include <status.h>
  78. #include <sched.h>
  79. #include <sigInt.h>
  80. #include <rpc.h>
  81. #include <net.h>
  82. #include <vm.h>
  83. #include <bstring.h>
  84. #include <stdio.h>
  85.  
  86. unsigned int     sigBitMasks[SIG_NUM_SIGNALS];
  87. int        sigDefActions[SIG_NUM_SIGNALS];
  88. int        sigCanHoldMask;
  89.  
  90. Sync_Lock    sigLock;
  91. Sync_Condition    signalCondition;
  92.  
  93. static void LocalSend _ARGS_((Proc_ControlBlock *procPtr, int sigNum, int code,
  94.             Address addr));
  95.  
  96.  
  97. /*
  98.  *----------------------------------------------------------------------
  99.  *
  100.  * Sig_Init --
  101.  *
  102.  *    Initialize the signal data structures.
  103.  *
  104.  * Results:
  105.  *    None.
  106.  *
  107.  * Side effects:
  108.  *    The set of bit masks and the set of default actions are set up.
  109.  *
  110.  *----------------------------------------------------------------------
  111.  */
  112.  
  113. void
  114. Sig_Init()
  115. {
  116.     int    i;
  117.  
  118.     Sync_LockInitDynamic(&sigLock, "Sig:sigLock");
  119.  
  120.     for (i = SIG_MIN_SIGNAL; i < SIG_NUM_SIGNALS; i++) {
  121.     sigBitMasks[i] = Sig_NumberToMask(i);
  122.     sigDefActions[i] = SIG_KILL_ACTION;
  123.     }
  124.  
  125.     /* 
  126.      * Note that SIG_RESUME uses the "kill" action, even though it's not 
  127.      * actually used to kill the process.
  128.      */
  129.     sigDefActions[SIG_DEBUG]        = SIG_DEBUG_ACTION;
  130.     sigDefActions[SIG_ARITH_FAULT]    = SIG_DEBUG_ACTION;
  131.     sigDefActions[SIG_ILL_INST]     = SIG_DEBUG_ACTION;
  132.     sigDefActions[SIG_ADDR_FAULT]     = SIG_DEBUG_ACTION;
  133.     sigDefActions[SIG_BREAKPOINT]     = SIG_DEBUG_ACTION;
  134.     sigDefActions[SIG_TRACE_TRAP]     = SIG_DEBUG_ACTION;
  135.     sigDefActions[SIG_MIGRATE_TRAP]     = SIG_MIGRATE_ACTION;
  136.     sigDefActions[SIG_MIGRATE_HOME]     = SIG_MIGRATE_ACTION;
  137.     sigDefActions[SIG_SUSPEND]        = SIG_SUSPEND_ACTION;
  138.     sigDefActions[SIG_TTY_INPUT]    = SIG_SUSPEND_ACTION;
  139.     sigDefActions[SIG_URGENT]        = SIG_IGNORE_ACTION;
  140.     sigDefActions[SIG_CHILD]        = SIG_IGNORE_ACTION;
  141.     sigDefActions[SIG_TTY_SUSPEND]    = SIG_SUSPEND_ACTION;
  142.     sigDefActions[SIG_TTY_OUTPUT]    = SIG_SUSPEND_ACTION;
  143.     sigDefActions[SIG_IO_READY]        = SIG_IGNORE_ACTION;
  144.     sigDefActions[SIG_WINDOW_CHANGE]    = SIG_IGNORE_ACTION;
  145.  
  146.     sigCanHoldMask = 
  147.           ~(sigBitMasks[SIG_ARITH_FAULT] | sigBitMasks[SIG_ILL_INST] |
  148.         sigBitMasks[SIG_ADDR_FAULT]  | sigBitMasks[SIG_KILL] |
  149.         sigBitMasks[SIG_BREAKPOINT]  | sigBitMasks[SIG_TRACE_TRAP] |
  150.         sigBitMasks[SIG_MIGRATE_HOME] | sigBitMasks[SIG_SUSPEND]);
  151. }
  152.  
  153.  
  154. /*
  155.  *----------------------------------------------------------------------
  156.  *
  157.  * Sig_ProcInit --
  158.  *
  159.  *    Initialize the signal data structures for the first process.
  160.  *
  161.  * Results:
  162.  *    None.
  163.  *
  164.  * Side effects:
  165.  *    Signal state initialized.
  166.  *
  167.  *----------------------------------------------------------------------
  168.  */
  169. void
  170. Sig_ProcInit(procPtr)
  171.     register    Proc_ControlBlock    *procPtr;
  172. {
  173.     procPtr->sigHoldMask = 0;
  174.     procPtr->sigPendingMask = 0;
  175.     bcopy((Address)sigDefActions,(Address)procPtr->sigActions,
  176.               sizeof(sigDefActions));
  177.     bzero((Address)procPtr->sigMasks,sizeof(procPtr->sigMasks)); 
  178.     bzero((Address)procPtr->sigCodes,sizeof(procPtr->sigCodes));
  179.     procPtr->sigFlags = 0;
  180. }
  181.  
  182.  
  183.  
  184. /*
  185.  *----------------------------------------------------------------------
  186.  *
  187.  * Sig_Fork --
  188.  *
  189.  *    Copy over the parents signal state into the child.
  190.  *
  191.  * Results:
  192.  *    None.
  193.  *
  194.  * Side effects:
  195.  *    Signal state copied from parent to child and pending mask cleared in
  196.  *    child.  Migration is held until the first return into user mode.
  197.  *
  198.  *----------------------------------------------------------------------
  199.  */
  200. void
  201. Sig_Fork(parProcPtr, childProcPtr)
  202.     register    Proc_ControlBlock    *parProcPtr;
  203.     register    Proc_ControlBlock    *childProcPtr;
  204. {
  205.     /*
  206.      * Copy the parent's signal state to the child.  Set up migration
  207.      * to be held initially.  On the first return to user mode, after
  208.      * signals are processed, migration will be reenabled.
  209.      */
  210.     childProcPtr->sigHoldMask = parProcPtr->sigHoldMask |
  211.         Sig_NumberToMask(SIG_MIGRATE_TRAP);
  212.     childProcPtr->sigPendingMask = 0;
  213.     bcopy((Address)parProcPtr->sigActions, 
  214.       (Address)childProcPtr->sigActions,
  215.       sizeof(childProcPtr->sigActions)); 
  216.     bcopy((Address)parProcPtr->sigMasks, 
  217.       (Address)childProcPtr->sigMasks,
  218.           sizeof(childProcPtr->sigMasks)); 
  219.     bzero((Address)childProcPtr->sigCodes,sizeof(childProcPtr->sigCodes));
  220.     childProcPtr->sigFlags = 0;
  221. }
  222.  
  223.  
  224. /*
  225.  *----------------------------------------------------------------------
  226.  *
  227.  * Sig_Exec --
  228.  *
  229.  *    Clear all signal handlers on exec.  Assumed called with the proc
  230.  *     table entry locked such that signals against this process are
  231.  *    prevented.
  232.  *
  233.  * Results:
  234.  *    None.
  235.  *
  236.  * Side effects:
  237.  *    All signal handlers are cleared and the pending mask is cleared.
  238.  *
  239.  *----------------------------------------------------------------------
  240.  */
  241. void
  242. Sig_Exec(procPtr)
  243.     Proc_ControlBlock    *procPtr;
  244. {
  245.     register    int    *actionPtr;
  246.     register    int    i;
  247.  
  248.     for (i = SIG_MIN_SIGNAL, actionPtr = &procPtr->sigActions[SIG_MIN_SIGNAL]; 
  249.      i < SIG_NUM_SIGNALS;
  250.      i++, actionPtr++) {
  251.     if (*actionPtr > SIG_SUSPEND_ACTION) {
  252.         /*
  253.          * The action contains a signal handler to call.  Reset back to
  254.          * the default action.
  255.          */
  256.         *actionPtr = sigDefActions[i];
  257.         procPtr->sigMasks[i] = 0;
  258.     }
  259.     }
  260.     procPtr->sigPendingMask = 0;
  261. }
  262.  
  263.  
  264. /*
  265.  *----------------------------------------------------------------------
  266.  *
  267.  * Sig_ChangeState --
  268.  *
  269.  *    Set the entire signal state of the process to that given.  When
  270.  *    setting the state verify that improper signals are not blocked or
  271.  *    ignored.  The process is assumed to be locked.
  272.  *
  273.  * Results:
  274.  *    None.
  275.  *
  276.  * Side effects:
  277.  *    The signal actions and hold mask will be set for the process.  
  278.  *    Might change the suspend/resume flags in the PCB.
  279.  *
  280.  *----------------------------------------------------------------------
  281.  */
  282.  
  283. ENTRY void
  284. Sig_ChangeState(procPtr, actions, sigMasks, pendingMask, sigCodes, holdMask)
  285.     register    Proc_ControlBlock    *procPtr;
  286.     int                    actions[];
  287.     register    int            sigMasks[];
  288.     int                    pendingMask;
  289.     int                    sigCodes[];
  290.     int                    holdMask;
  291. {
  292.     register    int    i;
  293.     register    int    *actionPtr;
  294.  
  295.     LOCK_MONITOR;
  296.  
  297.     for (i = SIG_MIN_SIGNAL, actionPtr = &actions[SIG_MIN_SIGNAL]; 
  298.      i < SIG_NUM_SIGNALS; 
  299.      i++, actionPtr++) {
  300.     if (i == SIG_KILL) {
  301.         continue;
  302.     }
  303.     procPtr->sigActions[i] = *actionPtr;
  304.     if (*actionPtr == SIG_IGNORE_ACTION) {
  305.         /*
  306.          * If is ignore action then make sure that is not one of the
  307.          * signals that cannot be ignored.  If not then remove the signal
  308.          * from the pending mask.
  309.          */
  310.         if (sigBitMasks[i] & sigCanHoldMask) {
  311.         pendingMask &= ~sigBitMasks[i];
  312.         } else {
  313.         procPtr->sigActions[i] = sigDefActions[i];
  314.         }
  315.     } else if (*actionPtr > SIG_NUM_ACTIONS) {
  316.         /*
  317.          * If greater than one of the actions then must be the address
  318.          * of a signal handler so store the signal mask.
  319.          */
  320.         procPtr->sigMasks[i] = sigMasks[i] & sigCanHoldMask;
  321.     }
  322.     }
  323.  
  324.     procPtr->sigPendingMask = pendingMask;
  325.     
  326.     /* 
  327.      * Make sure the suspend/resume flags are consistent with the pending 
  328.      * signals mask.
  329.      */
  330.     procPtr->genFlags &= ~PROC_RESUME_PROCESS;
  331.     if (pendingMask & Sig_NumberToMask(SIG_SUSPEND)) {
  332.     procPtr->genFlags |= PROC_PENDING_SUSPEND;
  333.     } else {
  334.     procPtr->genFlags &= ~PROC_PENDING_SUSPEND;
  335.     }
  336.  
  337.     procPtr->sigHoldMask = holdMask & sigCanHoldMask;
  338.     bcopy((Address) sigCodes, (Address) procPtr->sigCodes,
  339.           sizeof(procPtr->sigCodes));
  340.     procPtr->specialHandling = 1;
  341.  
  342.     UNLOCK_MONITOR;
  343. }
  344.  
  345.  
  346. /*
  347.  *----------------------------------------------------------------------
  348.  *
  349.  * Sig_UserSend --
  350.  *    Send a signal to a process.  Call the internal routine to do the
  351.  *    work.
  352.  *
  353.  * Results:
  354.  *    None.
  355.  *
  356.  * Side effects:
  357.  *    None.
  358.  *
  359.  *----------------------------------------------------------------------
  360.  */
  361.  
  362. ReturnStatus    
  363. Sig_UserSend(sigNum, pid, familyID)
  364.     int        sigNum;        /* The signal to send. */
  365.     Proc_PID    pid;        /* The id number of the process or process
  366.                    family. */
  367.     Boolean    familyID;    /* Whether the id is a process id or a process
  368.                    group id. */
  369. {
  370.     return(Sig_Send(sigNum, SIG_NO_CODE, pid, familyID, (Address)0));
  371. }
  372.  
  373.  
  374. /*
  375.  *----------------------------------------------------------------------
  376.  *
  377.  * LocalSend --
  378.  *
  379.  *    Send a signal to a process on the local machine.  It assumed that the
  380.  *    process is locked down when we are called.
  381.  *
  382.  * Results:
  383.  *    None.
  384.  *
  385.  * Side effects:
  386.  *    Signal pending mask and code modified.  The process's suspend and 
  387.  *    resume flags might also get changed.
  388.  *
  389.  *----------------------------------------------------------------------
  390.  */
  391.  
  392. ENTRY static void
  393. LocalSend(procPtr, sigNum, code, addr)
  394.     register    Proc_ControlBlock    *procPtr;
  395.     int                    sigNum;
  396.     int                    code;
  397.     Address                addr;
  398. {
  399.     int    sigBitMask;
  400.  
  401.     LOCK_MONITOR;
  402.  
  403.     /*
  404.      * Signals can't be sent to kernel processes unless the system is being
  405.      * shutdown since kernel processes never get the opportunity to handle
  406.      * signals.
  407.      */
  408.     if ((procPtr->genFlags & PROC_KERNEL) && !sys_ShuttingDown) {
  409.     UNLOCK_MONITOR;
  410.     return;
  411.     }
  412.  
  413.     if ((procPtr->sigActions[sigNum] == SIG_DEBUG_ACTION) &&
  414.     proc_KillMigratedDebugs && (procPtr->genFlags & PROC_FOREIGN)) {
  415.     /*
  416.      * Kill the process rather than letting it go silently into that
  417.      * good night (on the wrong machine).   Debugging migrated
  418.      * processes is nasty.  It would be nice if we could redirect
  419.      * the printf to the process's home node, too.
  420.      */
  421.     sigNum = SIG_KILL;
  422.     if (proc_MigDebugLevel > 1) {
  423.         printf("Warning: killing a migrated process that would have gone into the debugger, pid %x rpid %x uid %d.\n",
  424.             procPtr->processID, (int) procPtr->peerProcessID, 
  425.         procPtr->userID);
  426.  
  427.     }
  428.     }
  429.  
  430.     /*
  431.      * Only send the signal if it shouldn't be ignored and if it isn't
  432.      * a signal to migrate an unmigrated process.  (The latter can easily
  433.      * happen when signalling a process family to migrate home.)
  434.      */
  435.     if ((procPtr->sigActions[sigNum] != SIG_IGNORE_ACTION) &&
  436.     !((sigNum == SIG_MIGRATE_HOME) && (procPtr->peerHostID == NIL))) {
  437.  
  438.     if (sigNum == SIG_RESUME) {
  439.         /* 
  440.          * Resume the suspended process.
  441.          */
  442.         Proc_ResumeProcess(procPtr, FALSE);
  443.     }
  444.     if (procPtr->sigActions[sigNum] == SIG_SUSPEND_ACTION &&
  445.            procPtr->state == PROC_SUSPENDED) {
  446.         /*
  447.          * Are sending a suspend signal to a process that is already
  448.          * suspended.  In this case just notify the parent that the 
  449.          * process has been suspended.  This is necessary because resume
  450.          * signals are sent by processes to debugged processes which do not
  451.          * really get resumed.  However, the signaling process will not
  452.          * be informed that the process it sent the signal to did not get
  453.          * resumed (SIG_RESUME works regardless whether it actually 
  454.          * resumes anything or not).  Thus a process may believe that
  455.          * a process is running even though it really isn't and it may
  456.          * send a suspend signal to an already suspended process.
  457.          *
  458.          * There is a potential race here between a process getting
  459.          * suspended and us checking here but it doesn't matter.  If
  460.          * it gets suspended after we check then the parent will get 
  461.          * notified anyway.
  462.          */
  463.         Proc_InformParent(procPtr, PROC_SUSPEND_STATUS);
  464.     } else if (sigNum != SIG_RESUME ||
  465.         procPtr->sigActions[sigNum] != SIG_KILL_ACTION) {
  466.         sigBitMask = sigBitMasks[sigNum];
  467.         procPtr->sigPendingMask |= sigBitMask;
  468.         procPtr->sigCodes[sigNum] = code;
  469.         procPtr->sigAddr = (int)addr;
  470.         if (sigNum == SIG_SUSPEND) {
  471.         /* 
  472.          * Set the "pending suspend" flag in case the process is 
  473.          * resumed before it actually suspends.  Clear the "resume" 
  474.          * flag in case the process is resumed and then suspended 
  475.          * again before the first suspend is processed.
  476.          */
  477.         procPtr->genFlags |= PROC_PENDING_SUSPEND;
  478.         procPtr->genFlags &= ~PROC_RESUME_PROCESS;
  479.         }
  480.         if (procPtr->sigHoldMask & sigBitMask & ~sigCanHoldMask) {
  481.         /*
  482.          * We received a signal that was blocked but can't be blocked
  483.          * by users.  It only can be blocked if we are in the middle of
  484.          * executing a signal handler for the signal.  So we set things
  485.          * up to take the default action and make the signal unblocked
  486.          * so that we don't get an infinite loop of errors.
  487.          */
  488.         procPtr->sigHoldMask &= ~sigBitMask;
  489.         procPtr->sigActions[sigNum] = sigDefActions[sigNum];
  490.         }
  491.         procPtr->specialHandling = 1;
  492.         /*
  493.          * If the process is waiting then wake it up.
  494.          */
  495.         Sync_WakeWaitingProcess(procPtr);
  496.         if (sigNum == SIG_KILL || sigNum == SIG_MIGRATE_TRAP ||
  497.         sigNum == SIG_MIGRATE_HOME) {
  498.         if (sigNum == SIG_KILL && procPtr->state == PROC_NEW &&
  499.             (procPtr->genFlags & PROC_FOREIGN)) {
  500.             /*
  501.              * The process was only partially created.  We can't make
  502.              * it runnable so we have to reclaim it directly.
  503.              * Do this in the background so that
  504.              * Proc_DestroyMigratedProc has to wait for Sig_Send
  505.              * to unlock the process and we avoid a race condition.
  506.              */
  507.             Proc_CallFunc(Proc_DestroyMigratedProc,
  508.                   (ClientData) procPtr->processID, 0);
  509.         } else {
  510.             /*
  511.              * Resume the process so that we can perform the signal.
  512.              * If we're killing it, we tell Proc_ResumeProcess so it
  513.              * will even wake up a debugged process.
  514.              */
  515.             Proc_ResumeProcess(procPtr,
  516.                        (sigNum == SIG_KILL) ? TRUE : FALSE);
  517.         }
  518.         }
  519.     }
  520.     }
  521.     UNLOCK_MONITOR;
  522. }
  523.  
  524.  
  525. /*
  526.  *----------------------------------------------------------------------
  527.  *
  528.  * Sig_SendProc --
  529.  *
  530.  *    Store the signal in the pending mask and store the code for the given
  531.  *    process.  The code and addr are passed to the user interrupt
  532.  *    handler.  The code indicates the cause of the signal.  The addr
  533.  *    indicates the address of the fault.
  534.  *
  535.  *    NOTE: Assumes that we are called without the master lock down and
  536.  *    with the process locked.
  537.  *
  538.  * Results:
  539.  *    In the case of a local process, SUCCESS is returned.  If the process
  540.  *    is migrated, error conditions such as RPC_TIMEOUT may be returned.
  541.  *
  542.  * Side effects:
  543.  *    Signal pending mask and code modified.  If the process being signalled
  544.  *    is migrated, an RPC is sent.  If the process is local, the sched_Mutex
  545.  *    master lock is grabbed.
  546.  *
  547.  *----------------------------------------------------------------------
  548.  */
  549. ReturnStatus
  550. Sig_SendProc(procPtr, sigNum, code, addr)
  551.     register    Proc_ControlBlock *procPtr;
  552.     int                  sigNum;
  553.     int                  code;
  554.     Address              addr;
  555. {
  556.     ReturnStatus status;
  557.  
  558.     /*
  559.      * Make sure that the signal is in range.
  560.      */
  561.     if (sigNum < SIG_MIN_SIGNAL || sigNum >= SIG_NUM_SIGNALS) {
  562.     if (sigNum == 0) {
  563.         return(SUCCESS);
  564.     } else {
  565.         return(SIG_INVALID_SIGNAL);
  566.     }
  567.     }
  568.  
  569.     /*
  570.      * Handle migrated processes specially. There's a race condition
  571.      * when sending a signal to a migrated process, since it can
  572.      * migrate back to this host while we're doing it.  Therefore,
  573.      * if the problem was that the process didn't exist, check
  574.      * to see if it has migrated back to this host (it's no longer MIGRATED).
  575.      * We don't have to check for MIGRATING, since SigMigSend waits for
  576.      * a migration in progress to complete.   Also make sure that while the
  577.      * signal is sent and the process is unlocked, it processID doesn't change.
  578.      */
  579.     if (procPtr->state == PROC_MIGRATED ||
  580.         (procPtr->genFlags & PROC_MIGRATING)) {
  581.     Proc_PID processID;
  582.     processID = procPtr->processID;
  583.     status = SigMigSend(procPtr, sigNum, code, addr);
  584.     if (processID != procPtr->processID) {
  585.         return(status);
  586.     }
  587.     if ((status != PROC_INVALID_PID) ||
  588.         (procPtr->state == PROC_MIGRATED)) {
  589.         return(status);
  590.     }
  591.     }
  592.     if (procPtr->state == PROC_EXITING) {
  593.     return(PROC_INVALID_PID);
  594.     } else if (procPtr->state == PROC_NEW) {
  595.     if (procPtr->genFlags & PROC_FOREIGN && proc_MigDebugLevel > 0) {
  596.         printf("Warning: got signal for process %x before migration complete.\n",
  597.            procPtr->processID);
  598.     }
  599.     return(PROC_INVALID_PID);
  600.     } else {
  601.     LocalSend(procPtr, sigNum, code, addr);
  602.     return(SUCCESS);
  603.     }
  604. }
  605.  
  606.  
  607. /*
  608.  *----------------------------------------------------------------------
  609.  *
  610.  * Sig_Send --
  611.  *
  612.  *    Send a signal to a process.  This entails marking the signal into
  613.  *    the signal pending mask for the process and waking up the process
  614.  *    if it is asleep.   
  615.  *
  616.  * Results:
  617.  *    An error is the signal or the process id are invalid.  SUCCESS 
  618.  *    otherwise.
  619.  *
  620.  * Side effects:
  621.  *    The signal information in the proc table for the process that
  622.  *    is being sent the signal may be modified.
  623.  *
  624.  *----------------------------------------------------------------------
  625.  */
  626.  
  627. ReturnStatus    
  628. Sig_Send(sigNum, code, id, familyID, addr)
  629.     int        sigNum;        /* The signal to send. */
  630.     int        code;        /* The code that goes with the signal. */
  631.     Proc_PID    id;        /* The id number of the process or process
  632.                    family. */
  633.     Boolean    familyID;    /* Whether the id is a process id or a process
  634.                    group id. */
  635.     Address    addr;        /* The address of the fault */
  636. {
  637.     register    Proc_ControlBlock    *procPtr;
  638.     Proc_PCBLink            *procLinkPtr;
  639.     ReturnStatus            status;
  640.     List_Links                *familyList;
  641.     int                    userID;
  642.     int                    hostID;
  643.  
  644.     if (!Proc_ComparePIDs(id, PROC_MY_PID)) {
  645.     hostID = Proc_GetHostID(id);
  646.     if (hostID != rpc_SpriteID) {
  647.         /*
  648.          * Send a remote signal.
  649.          */
  650.         if (hostID == NET_BROADCAST_HOSTID ||
  651.         hostID >  NET_NUM_SPRITE_HOSTS || hostID < 0) {
  652.         return(PROC_INVALID_PID);
  653.         } else {
  654.         return(SigSendRemoteSignal(hostID, sigNum, code, id,
  655.                        familyID, addr));
  656.         }
  657.     }
  658.     }
  659.     /*
  660.      * Get the pointer to the control block if this is a valid process id.
  661.      */
  662.     if (!familyID) {
  663.     if (Proc_ComparePIDs(id, PROC_MY_PID)) {
  664.         procPtr = Proc_GetEffectiveProc();
  665.         if (procPtr == (Proc_ControlBlock *) NIL) {
  666.         panic("Sig_Send: procPtr == NIL\n");
  667.         }
  668.         Proc_Lock(procPtr);
  669.     } else {
  670.         procPtr = Proc_LockPID(id);
  671.         if (procPtr == (Proc_ControlBlock *) NIL) {
  672.         return(PROC_INVALID_PID);
  673.         }
  674.         if (!Proc_HasPermission(procPtr->effectiveUserID)) {
  675.         Proc_Unlock(procPtr);
  676.         return(PROC_UID_MISMATCH);
  677.         }
  678.     }
  679.     status = Sig_SendProc(procPtr, sigNum, code, addr);
  680.     Proc_Unlock(procPtr);
  681.     } else {
  682.     Proc_PID *pidArray;
  683.     int i;
  684.     int numProcs;
  685.     
  686.     status = Proc_LockFamily((int)id, &familyList, &userID);
  687.     if (status != SUCCESS) {
  688.         return(status);
  689.     }
  690.     if (!Proc_HasPermission(userID)) {
  691.             Proc_UnlockFamily((int)id);
  692.             return(PROC_UID_MISMATCH);
  693.         }
  694.  
  695.     /*
  696.      * Send a signal to everyone in the given family.  We do this
  697.      * by grabbing a list of process IDs and then sending the signals
  698.      * with the family not locked, to avoid deadlocks resulting from
  699.      * signals being sent with the family locked.
  700.      */
  701.  
  702.     numProcs = 0;
  703.     LIST_FORALL(familyList, (List_Links *) procLinkPtr) {
  704.         numProcs++;
  705.     }
  706.     pidArray = (Proc_PID *) malloc(numProcs * sizeof(Proc_PID));
  707.     i = 0;
  708.     LIST_FORALL(familyList, (List_Links *) procLinkPtr) {
  709.         procPtr = procLinkPtr->procPtr;
  710.         Proc_Lock(procPtr);
  711.         pidArray[i] = procPtr->processID;
  712.         Proc_Unlock(procPtr);
  713.         i++;
  714.         if (i > numProcs) {
  715.         panic("Sig_Send: process family changed size while locked.\n");
  716.         free((Address) pidArray);
  717.         return(FAILURE);
  718.         }
  719.     }
  720.     Proc_UnlockFamily((int)id);
  721.     for (i = 0; i < numProcs; i++) {
  722.         procPtr = Proc_LockPID(pidArray[i]);
  723.         if (procPtr == (Proc_ControlBlock *) NIL) {
  724.         /*
  725.          * Race condition: process got removed.
  726.          */
  727.         continue;
  728.         }
  729.         status = Sig_SendProc(procPtr, sigNum, code, addr);
  730.         Proc_Unlock(procPtr); 
  731.         if (status != SUCCESS) {
  732.         break;
  733.         }
  734.     }
  735.     free((Address) pidArray);
  736.     }
  737.  
  738.     return(status);
  739. }
  740.  
  741. typedef struct {
  742.     int        sigNum;
  743.     int        code;
  744.     Proc_PID    id;
  745.     Boolean        familyID;
  746.     int        effUid;
  747.     Address        addr;
  748. } SigParms;
  749.  
  750.  
  751. /*
  752.  *----------------------------------------------------------------------
  753.  *
  754.  * SigSendRemoteSignal --
  755.  *
  756.  *    Send a signal to a process on a remote machine.
  757.  *
  758.  * Results:
  759.  *    Return the status from the remote machine.
  760.  *
  761.  * Side effects:
  762.  *    None.
  763.  *
  764.  *----------------------------------------------------------------------
  765.  */
  766. ReturnStatus    
  767. SigSendRemoteSignal(hostID, sigNum, code, id, familyID, addr)
  768.     int        hostID;        /* Host to send message to. */
  769.     int        sigNum;        /* Signal to send. */
  770.     int        code;        /* Code to send. */
  771.     Proc_PID    id;        /* ID to send it to. */
  772.     Boolean    familyID;    /* TRUE if are sending to a process family. */
  773.     Address    addr;        /* Address of signal. */
  774. {
  775.     SigParms        sigParms;
  776.     Rpc_Storage        storage;
  777.     Proc_ControlBlock    *procPtr;
  778.  
  779.     sigParms.sigNum = sigNum;
  780.     sigParms.code = code;
  781.     sigParms.id = id;
  782.     sigParms.familyID = familyID;
  783.     procPtr = Proc_GetEffectiveProc();
  784.     sigParms.effUid = procPtr->effectiveUserID;
  785.     sigParms.addr = addr;
  786.  
  787.     storage.requestParamPtr = (Address)&sigParms;
  788.     storage.requestParamSize = sizeof(sigParms);
  789.     storage.requestDataPtr = (Address)NIL;
  790.     storage.requestDataSize = 0;
  791.     storage.replyParamPtr = (Address)NIL;
  792.     storage.replyParamSize = 0;
  793.     storage.replyDataPtr = (Address)NIL;
  794.     storage.replyDataSize = 0;
  795.  
  796.     return(Rpc_Call(hostID, RPC_SIG_SEND, &storage));
  797.  
  798. }
  799.  
  800.  
  801. /*
  802.  *----------------------------------------------------------------------
  803.  *
  804.  * Sig_RpcSend --
  805.  *
  806.  *    Stub to handle a remote signal RPC.
  807.  *
  808.  * Results:
  809.  *    SUCCESS.
  810.  *
  811.  * Side effects:
  812.  *    Reply is sent.
  813.  *
  814.  *----------------------------------------------------------------------
  815.  */
  816. /*ARGSUSED*/
  817. ReturnStatus    
  818. Sig_RpcSend(srvToken, clientID, command, storagePtr)
  819.     ClientData          srvToken;    /* Handle on server process passed to
  820.                       * Rpc_Reply */
  821.     int          clientID;    /* Sprite ID of client host */
  822.     int          command;    /* Command identifier */
  823.     register Rpc_Storage *storagePtr;    /* The request fields refer to the 
  824.                      * request buffers and also indicate 
  825.                      * the exact amount of data in the 
  826.                      * request buffers.  The reply fields 
  827.                      * are initialized to NIL for the
  828.                       * pointers and 0 for the lengths.  
  829.                      * This can be passed to Rpc_Reply */
  830. {
  831.     SigParms        *sigParmsPtr;
  832.     ReturnStatus    status;
  833.     Proc_ControlBlock    *procPtr;
  834.     int            effUid;
  835.  
  836.     sigParmsPtr = (SigParms *) storagePtr->requestParamPtr;
  837.     procPtr = Proc_GetCurrentProc();
  838.     effUid = procPtr->effectiveUserID;
  839.     procPtr->effectiveUserID = sigParmsPtr->effUid;
  840.     status = Sig_Send(sigParmsPtr->sigNum, sigParmsPtr->code, sigParmsPtr->id,
  841.               sigParmsPtr->familyID, sigParmsPtr->addr);
  842.     procPtr->effectiveUserID = effUid;
  843.     Rpc_Reply(srvToken, status, storagePtr, (int(*)())NIL, (ClientData)NIL);
  844.     return(SUCCESS);
  845. }
  846.  
  847.  
  848. /*
  849.  *----------------------------------------------------------------------
  850.  *
  851.  * Sig_SetHoldMask --
  852.  *
  853.  *    Set the signal hold mask for the current process.  Return the
  854.  *    old mask.  No synchronization required since the only process
  855.  *    that can modify the hold mask is this process.
  856.  *
  857.  * Results:
  858.  *    Error if the place to store the old mask is invalid,  SUCCESS
  859.  *    otherwise.
  860.  *
  861.  * Side effects:
  862.  *    None.
  863.  *
  864.  *----------------------------------------------------------------------
  865.  */
  866.  
  867. ReturnStatus    
  868. Sig_SetHoldMask(newMask, oldMaskPtr)
  869.     int    newMask;    /* Mask to set the hold mask to. */
  870.     int    *oldMaskPtr;    /* Where to store the old mask. */
  871. {
  872.     register    Proc_ControlBlock    *procPtr;
  873.  
  874.     /*
  875.      * Get out the old mask value and store the new one.
  876.      */
  877.  
  878.     procPtr = Proc_GetActualProc();
  879.  
  880.     if (oldMaskPtr != USER_NIL) {
  881.     if (Vm_CopyOut(sizeof(procPtr->sigHoldMask), 
  882.                (Address) &(procPtr->sigHoldMask),
  883.                (Address) oldMaskPtr) != SUCCESS) {
  884.         return(SYS_ARG_NOACCESS);
  885.     }
  886.     }
  887.  
  888.     procPtr->sigHoldMask = newMask & sigCanHoldMask;
  889.     procPtr->specialHandling = 1;
  890.  
  891.     return(SUCCESS);
  892. }
  893.  
  894.  
  895. /*
  896.  *----------------------------------------------------------------------
  897.  *
  898.  * Sig_SetAction --
  899.  *
  900.  *    Set the action for a particular signal.
  901.  *
  902.  * Results:
  903.  *    Error if the action, signal, or handler is invalid.
  904.  *
  905.  * Side effects:
  906.  *    The sigAction and sigMasks fields may be modified for the
  907.  *    particular signal.
  908.  *
  909.  *----------------------------------------------------------------------
  910.  */
  911.  
  912. ReturnStatus    
  913. Sig_SetAction(sigNum, newActionPtr, oldActionPtr)
  914.     int        sigNum;           /* The signal for which the action is to be 
  915.                   set. */
  916.     Sig_Action    *newActionPtr; /* The actions to take for the signal. */
  917.     Sig_Action    *oldActionPtr; /* The action that was taken for the signal. */
  918. {
  919.     Proc_ControlBlock    *procPtr;
  920.     Address        dummy;
  921.     Sig_Action        action;
  922.  
  923.     /*
  924.      * Make sure that the signal is in range.
  925.      */
  926.     if (sigNum < SIG_MIN_SIGNAL || sigNum >= SIG_NUM_SIGNALS || 
  927.     sigNum == SIG_KILL || sigNum == SIG_SUSPEND) {
  928.     return(SIG_INVALID_SIGNAL);
  929.     }
  930.  
  931.     procPtr = Proc_GetActualProc();
  932.  
  933.     /* 
  934.      * Copy out the current action.  There are two cases:
  935.      *
  936.      *    1) The current action really contains a handler to call.  Thus
  937.      *         the current action is SIG_HANDLE_ACTION.
  938.      *      2) The current action is one of the other four actions.
  939.      */
  940.  
  941.     if (oldActionPtr != (Sig_Action *) USER_NIL) {
  942.     if (procPtr->sigActions[sigNum] > SIG_NUM_ACTIONS) {
  943.         action.action = SIG_HANDLE_ACTION;
  944.         action.handler = (int (*)())procPtr->sigActions[sigNum];
  945.         action.sigHoldMask = procPtr->sigMasks[sigNum];
  946.     } else {
  947.         if (procPtr->sigActions[sigNum] == sigDefActions[sigNum]) {
  948.         action.action = SIG_DEFAULT_ACTION;
  949.         } else {
  950.         action.action = procPtr->sigActions[sigNum];
  951.         }
  952.     }
  953.     if (Vm_CopyOut(sizeof(action), (Address) &action, 
  954.         (Address) oldActionPtr) != SUCCESS) {
  955.         return(SYS_ARG_NOACCESS);
  956.     }
  957.     }
  958.  
  959.     /*
  960.      * Copy in the action to take.
  961.      */
  962.  
  963.     if (Vm_CopyIn(sizeof(action), (Address) newActionPtr, 
  964.         (Address) &action) != SUCCESS) {
  965.     return(SYS_ARG_NOACCESS);
  966.     }
  967.  
  968.     /*
  969.      * Make sure that the action is valid.
  970.      */
  971.  
  972.     if (action.action < 0 || action.action > SIG_NUM_ACTIONS) {
  973.     return(SIG_INVALID_ACTION);
  974.     }
  975.  
  976.     if (action.action == SIG_DEFAULT_ACTION) {
  977.     action.action = sigDefActions[sigNum];
  978.     }
  979.  
  980.     /*
  981.      * Store the action.  If it is SIG_HANDLE_ACTION then the handler is stored
  982.      * in place of the action.
  983.      */
  984.  
  985.     if (action.action == SIG_HANDLE_ACTION) {
  986.     if (Vm_CopyIn(4, (Address) ((unsigned int) (action.handler)), 
  987.             (Address) &dummy) != SUCCESS) {
  988.         return(SYS_ARG_NOACCESS);
  989.     }
  990.     procPtr->sigMasks[sigNum] = 
  991.         (sigBitMasks[sigNum] | action.sigHoldMask) & sigCanHoldMask;
  992.     procPtr->sigActions[sigNum] = (unsigned int) action.handler;
  993.     } else if (action.action == SIG_IGNORE_ACTION) {
  994.  
  995.     /*
  996.      * Only actions that can be blocked can be ignored.  This prevents a
  997.      * user from ignoring a signal such as a bus error which would cause
  998.      * the process to take a bus error repeatedly.
  999.      */
  1000.  
  1001.     if (sigBitMasks[sigNum] & sigCanHoldMask) {
  1002.         procPtr->sigActions[sigNum] = SIG_IGNORE_ACTION;
  1003.         Proc_Lock(procPtr);
  1004.         SigClearPendingMask(procPtr, sigNum);
  1005.         if (sigNum == SIG_SUSPEND) {
  1006.         procPtr->genFlags &= ~(PROC_PENDING_SUSPEND |
  1007.                        PROC_RESUME_PROCESS);
  1008.         }
  1009.         Proc_Unlock(procPtr);
  1010.     } else {
  1011.         return(SIG_INVALID_SIGNAL);
  1012.     }
  1013.     procPtr->sigMasks[sigNum] = 0;
  1014.     } else {
  1015.     procPtr->sigActions[sigNum] = action.action;
  1016.     procPtr->sigMasks[sigNum] = 0;
  1017.     }
  1018.  
  1019.     return(SUCCESS);
  1020. }
  1021.  
  1022.  
  1023. /*
  1024.  *----------------------------------------------------------------------
  1025.  *
  1026.  * Sig_Pause --
  1027.  *
  1028.  *    Atomically change signal hold mask and wait for a signal to arrive.
  1029.  *
  1030.  * Results:
  1031.  *    None.
  1032.  *
  1033.  * Side effects:
  1034.  *    None.
  1035.  *
  1036.  *----------------------------------------------------------------------
  1037.  */
  1038.  
  1039. ENTRY ReturnStatus    
  1040. Sig_Pause(sigHoldMask)
  1041.     int    sigHoldMask;    /* The value that the mask of held signals is to be set
  1042.                to while waiting for a signal to arrive. */
  1043. {
  1044.     register    Proc_ControlBlock    *procPtr;
  1045.     ReturnStatus status;
  1046.     int migMask;
  1047.  
  1048.     LOCK_MONITOR;
  1049.  
  1050.     procPtr = Proc_GetActualProc();
  1051.  
  1052.     /*
  1053.      * The signal mask cannot be restored until the signal handler has
  1054.      * had a chance to be called for the signal that caused Sig_Pause
  1055.      * to return.  To allow this the current hold mask is stored in the
  1056.      * proc table and the flag sigPause is set to be true to indicate that
  1057.      * the hold mask has to be restored after the signal handler has had a
  1058.      * chance to be called.
  1059.      */
  1060.  
  1061.     procPtr->oldSigHoldMask = procPtr->sigHoldMask;
  1062.     procPtr->sigFlags |= SIG_PAUSE_IN_PROGRESS;
  1063.     procPtr->sigHoldMask = sigHoldMask & sigCanHoldMask;
  1064.     procPtr->specialHandling = 1;
  1065.  
  1066.     /*
  1067.      * Wait on the signal condition.  As it turns out since a signal
  1068.      * wakes up the process regardless what it is sleeping on, this condition
  1069.      * variable is never broadcasted on, but we have to wait on something in 
  1070.      * order to release the monitor lock.
  1071.      *
  1072.      * Don't let a Sig_Pause be interrupted by a migrate trap signal.
  1073.      * So, if none of the signal bits are set besides migration-related
  1074.      * signals, and a migration-related signal bit is set, let the user-level
  1075.      * code retry  the signal.
  1076.      */
  1077.     (void) Sync_Wait(&signalCondition, TRUE);
  1078.  
  1079.     migMask = (Sig_NumberToMask(SIG_MIGRATE_TRAP)) |
  1080.     (Sig_NumberToMask(SIG_MIGRATE_HOME));
  1081.     if ((! (procPtr->sigPendingMask & ~migMask)) &&
  1082.     (procPtr->sigPendingMask & migMask)) {
  1083.     status = GEN_ABORTED_BY_SIGNAL;
  1084.     } else {
  1085.     status = SUCCESS;
  1086.     }
  1087.     
  1088.     UNLOCK_MONITOR;
  1089.  
  1090.     return(status);
  1091. }
  1092.  
  1093.  
  1094. /*
  1095.  *----------------------------------------------------------------------
  1096.  *
  1097.  * SigClearPendingMask --
  1098.  *
  1099.  *    Remove the given signal from the pending mask.
  1100.  *
  1101.  * Results:
  1102.  *    None.
  1103.  *
  1104.  * Side effects:
  1105.  *    Pending mask for process modified.
  1106.  *
  1107.  *----------------------------------------------------------------------
  1108.  */
  1109.  
  1110. ENTRY void
  1111. SigClearPendingMask(procPtr, sigNum)
  1112.     register    Proc_ControlBlock    *procPtr;
  1113.     int                    sigNum;
  1114. {
  1115.     LOCK_MONITOR;
  1116.  
  1117.     procPtr->sigPendingMask &= ~sigBitMasks[sigNum];
  1118.  
  1119.     UNLOCK_MONITOR;
  1120. }
  1121.  
  1122. /*
  1123.  *---------------------------------------------------------------------------
  1124.  *
  1125.  * Routines for signal handlers --
  1126.  *
  1127.  * A signal handler is called right before a process is to return to 
  1128.  * user space.  In order to do this the current state before the signal
  1129.  * is taken must be saved, the signal handler called, and then the state
  1130.  * restored when the signal handler returns.  It is this modules responsibility
  1131.  * to handle the signal state;  all of the actual saving and restoring of
  1132.  * machine state and the calling of the handler is done in the machine
  1133.  * dependent routines in the mach module.
  1134.  */
  1135.  
  1136.  
  1137. /*
  1138.  *----------------------------------------------------------------------
  1139.  *
  1140.  * Sig_Handle --
  1141.  *
  1142.  *    Set things up so that the signal handler is called for one of the
  1143.  *    signals that are pending for the current process.  This is done
  1144.  *    by saving the old trap stack and modifying the current one.
  1145.  *
  1146.  * Results:
  1147.  *    Return TRUE if a signal is setup to be handled by the user.
  1148.  *
  1149.  * Side effects:
  1150.  *    *trapStackPtr is modified and also the user stack is modified.
  1151.  *
  1152.  *----------------------------------------------------------------------
  1153.  */
  1154. Boolean        
  1155. Sig_Handle(procPtr, sigStackPtr, pcPtr)
  1156.     register    Proc_ControlBlock    *procPtr;
  1157.     register    Sig_Stack        *sigStackPtr;
  1158.     Address                *pcPtr;
  1159. {
  1160.     int                    sigs;
  1161.     int                    sigNum;
  1162.     unsigned    int            *bitMaskPtr;
  1163.     int                    sigBitMask;
  1164.  
  1165.     /*
  1166.      * Find out which signals are pending.
  1167.      */
  1168.     sigs = procPtr->sigPendingMask & ~procPtr->sigHoldMask;
  1169.     if (sigs == 0) {
  1170.     return(FALSE);
  1171.     }
  1172.  
  1173.     /*
  1174.      * Check for the signal SIG_KILL.  This is processed specially because
  1175.      * it is how processes that have some problem such as being unable
  1176.      * to write to swap space on the file server are destroyed.
  1177.      */
  1178.     if (sigs & sigBitMasks[SIG_KILL]) {
  1179.     if (procPtr->sigCodes[SIG_KILL] != SIG_NO_CODE) {
  1180.         Proc_ExitInt(PROC_TERM_DESTROYED, 
  1181.             procPtr->sigCodes[SIG_KILL], 0);
  1182.     } else {
  1183.         Proc_ExitInt(PROC_TERM_SIGNALED, SIG_KILL, 0);
  1184.     }
  1185.     }
  1186.  
  1187.     for (sigNum = SIG_MIN_SIGNAL, bitMaskPtr = &sigBitMasks[SIG_MIN_SIGNAL];
  1188.      !(sigs & *bitMaskPtr);
  1189.      sigNum++, bitMaskPtr++) {
  1190.     }
  1191.  
  1192.     SigClearPendingMask(procPtr, sigNum);
  1193.  
  1194.     /*
  1195.      * Process the signal.
  1196.      */
  1197.     switch (procPtr->sigActions[sigNum]) {
  1198.     case SIG_IGNORE_ACTION:
  1199.         printf("Warning: %s\n",
  1200.         "Sig_Handle:  An ignored signal was in a signal pending mask.");
  1201.         return(FALSE);
  1202.  
  1203.     case SIG_KILL_ACTION:
  1204.         if (sigNum == SIG_KILL || !(procPtr->genFlags & PROC_DEBUGGED)) {
  1205.         Proc_ExitInt(PROC_TERM_SIGNALED, sigNum,
  1206.             procPtr->sigCodes[sigNum]);
  1207.         panic("Sig_Handle: Proc_Exit returned!\n");
  1208.         } else {
  1209.         /* Fall through */
  1210.         }
  1211.  
  1212.     case SIG_SUSPEND_ACTION:
  1213.     case SIG_DEBUG_ACTION:
  1214.         /* 
  1215.          * A suspended process and a debugged process are basically
  1216.          * the same.  A suspended process can be debugged just like
  1217.          * a process in the debug state.   The only difference is that
  1218.          * a suspended process does not go onto the debug list; it can
  1219.          * only be debugged by a debugger that specifically asks for
  1220.          * it.
  1221.          *
  1222.          * Suspend the process.
  1223.          */
  1224.         Proc_SuspendProcess(procPtr,
  1225.             procPtr->sigActions[sigNum] == SIG_DEBUG_ACTION,
  1226.             PROC_TERM_SIGNALED, sigNum, 
  1227.             procPtr->sigCodes[sigNum]);
  1228.         return(FALSE);
  1229.  
  1230.     case SIG_MIGRATE_ACTION:
  1231.         /*
  1232.          * If the process was in the middle of a page fault,
  1233.          * its PC in the trap stack is not useable.
  1234.          * Reset the pending condition but hold it until we get out of
  1235.          * the kernel.
  1236.          */
  1237.         if (!Mach_CanMigrate(procPtr)) {
  1238.         LocalSend(procPtr, sigNum, procPtr->sigCodes[sigNum],
  1239.             (Address)procPtr->sigAddr);
  1240.         procPtr->sigHoldMask |= Sig_NumberToMask(SIG_MIGRATE_TRAP);
  1241.         return(FALSE);
  1242.         }
  1243.  
  1244.         /*
  1245.          * Double-check against process not allowed to migrate.  This
  1246.          * can happen if a process migrates, opens a pdev as master,
  1247.          * and gets signalled to migrate home.
  1248.          */
  1249.         if (procPtr->genFlags & PROC_DONT_MIGRATE) {
  1250.         if (proc_MigDebugLevel > 0) {
  1251.             printf("Proc_Migrate: process %x is not allowed to migrate.\n",
  1252.                    procPtr->processID);
  1253.         }
  1254.         return(FALSE);
  1255.         }
  1256.         if (procPtr->peerHostID != NIL) {
  1257.         if (proc_MigDebugLevel > 6) {
  1258.             printf("Sig_Handle calling Proc_MigrateTrap for process %x.\n",
  1259.                    procPtr->processID);
  1260.         }
  1261.         Proc_MigrateTrap(procPtr);
  1262.         }
  1263.         return(FALSE);
  1264.  
  1265.     case SIG_DEFAULT_ACTION:
  1266.         panic("Sig_Handle: SIG_DEFAULT_ACTION found in array of actions?\n");
  1267.     }
  1268.  
  1269.     /*
  1270.      * Set up our part of the signal stack.
  1271.      */
  1272.     sigStackPtr->sigNum = sigNum;
  1273.     sigStackPtr->sigCode = procPtr->sigCodes[sigNum];
  1274.     sigStackPtr->sigAddr = procPtr->sigAddr;
  1275.     /*
  1276.      * If this signal handler is being called after a call to Sig_Pause then
  1277.      * the real signal hold mask has to be restored after the handler returns.
  1278.      * This is assured by pushing the real hold mask which is stored in 
  1279.      * the proc table onto the stack.
  1280.      */
  1281.     if (procPtr->sigFlags & SIG_PAUSE_IN_PROGRESS) {
  1282.     procPtr->sigFlags &= ~SIG_PAUSE_IN_PROGRESS;
  1283.     sigStackPtr->contextPtr->oldHoldMask = procPtr->oldSigHoldMask;
  1284.     } else {
  1285.     sigStackPtr->contextPtr->oldHoldMask = procPtr->sigHoldMask;
  1286.     }
  1287.  
  1288.     procPtr->sigHoldMask |= procPtr->sigMasks[sigNum];
  1289.     sigBitMask = sigBitMasks[sigNum];
  1290.     if (sigBitMask & ~sigCanHoldMask) {
  1291.     /*
  1292.      * If this is a non-blockable signal then add it to the hold mask
  1293.      * so that if we get it again we know that it can't be handled.
  1294.      */
  1295.     procPtr->sigHoldMask |= sigBitMask;
  1296.     }
  1297.     procPtr->specialHandling = 1;
  1298.     *pcPtr = (Address)procPtr->sigActions[sigNum];
  1299.     return(TRUE);
  1300. }
  1301.  
  1302.  
  1303. /*
  1304.  *----------------------------------------------------------------------
  1305.  *
  1306.  * Sig_Return --
  1307.  *
  1308.  *    Process a return from signal.
  1309.  *
  1310.  * Results:
  1311.  *    None.
  1312.  *
  1313.  * Side effects:
  1314.  *    The trap stack is modified.
  1315.  *
  1316.  *----------------------------------------------------------------------
  1317.  */
  1318. void        
  1319. Sig_Return(procPtr, sigStackPtr)
  1320.     register Proc_ControlBlock    *procPtr;    /* Process that is returning
  1321.                          * from a signal. */
  1322.     Sig_Stack            *sigStackPtr;    /* Signal stack. */
  1323. {
  1324.     procPtr->sigHoldMask = sigStackPtr->contextPtr->oldHoldMask;
  1325.     procPtr->specialHandling = 1;
  1326. }
  1327.  
  1328.  
  1329. /*
  1330.  *----------------------------------------------------------------------
  1331.  *
  1332.  * Sig_AllowMigration --
  1333.  *
  1334.  *    Set up a process to allow migration.  This is a special call
  1335.  *    because normally the SIG_MIGRATE_TRAP signal is not holdable in
  1336.  *    the first place.
  1337.  *
  1338.  *    This could be a macro and be called directly from
  1339.  *    Mach_StartUserProc, once things are stable....
  1340.  *
  1341.  * Results:
  1342.  *    None.
  1343.  *
  1344.  * Side effects:
  1345.  *    The process's hold mask is modified.
  1346.  *
  1347.  *----------------------------------------------------------------------
  1348.  */
  1349. void        
  1350. Sig_AllowMigration(procPtr)
  1351.     register Proc_ControlBlock    *procPtr;    /* process to modify */
  1352. {
  1353.     if (procPtr->sigHoldMask &&
  1354.     (procPtr->sigHoldMask & sigBitMasks[SIG_MIGRATE_TRAP])) {
  1355.         procPtr->sigHoldMask &= ~sigBitMasks[SIG_MIGRATE_TRAP];
  1356.     procPtr->specialHandling = 1;
  1357.     }
  1358. }
  1359.  
  1360.  
  1361. /*
  1362.  *----------------------------------------------------------------------
  1363.  *
  1364.  * Sig_CheckForKill --
  1365.  *
  1366.  *    Check if a process has a kill signal and kill it if so.
  1367.  *    Otherwise return.  this is for calling in difficult places where
  1368.  *    we can't allow any signals that would be handled in user mode to
  1369.  *    occur.
  1370.  *
  1371.  * Results:
  1372.  *    None.
  1373.  *
  1374.  * Side effects:
  1375.  *    Process may be killed.
  1376.  *
  1377.  *----------------------------------------------------------------------
  1378.  */
  1379. void        
  1380. Sig_CheckForKill(procPtr)
  1381.     Proc_ControlBlock    *procPtr;
  1382. {
  1383.     int                    sigs;
  1384.  
  1385.     /*
  1386.      * Find out which signals are pending.
  1387.      */
  1388.     sigs = procPtr->sigPendingMask & ~procPtr->sigHoldMask;
  1389.     if (sigs == 0) {
  1390.     return;
  1391.     }
  1392.  
  1393.     /*
  1394.      * Check for the signal SIG_KILL.  This is processed specially because
  1395.      * it is how processes that have some problem such as being unable
  1396.      * to write to swap space on the file server are destroyed.
  1397.      */
  1398.     if (sigs & sigBitMasks[SIG_KILL]) {
  1399.     if (procPtr->sigCodes[SIG_KILL] != SIG_NO_CODE) {
  1400.         Proc_ExitInt(PROC_TERM_DESTROYED, 
  1401.             procPtr->sigCodes[SIG_KILL], 0);
  1402.     } else {
  1403.         Proc_ExitInt(PROC_TERM_SIGNALED, SIG_KILL, 0);
  1404.     }
  1405.     }
  1406.     return;
  1407. }
  1408.